specialized.base.base_semantic_function(db).function_with_body_id(db),

                        // A specialized function should always inline its base.

    let specialized_func = SpecializedFunction {
        base: function_id,
        args: Arc::new([None, Some(ConstValue::Int(BigInt::one(), core.felt252))]),
    };

                base_sign.params = zip_eq(base_sign.params, &specialized.args)
                    .filter_map(|(param, arg)| arg.is_none().then_some(param))
                    .collect();

        FunctionLongId::Specialized(_) => unreachable!("Specialization of functions only occurs post concretization."),

            {
                let base = db.lowered_body(specialized.base, LoweringStage::Monomorphized)?;

                let base_semantic = specialized.base.base_semantic_function(db);

                let mut variables = VariableAllocator::new(
                    db,
                    base_semantic.function_with_body_id(db),
                    Default::default(),
                )?;
                let mut statement = vec![];
                let mut parameters = vec![];
                for (param, arg) in zip_eq(&base.parameters, specialized.args.iter()) {
                    let var_id = variables.variables.alloc(base.variables[*param].clone());
                    if let Some(arg) = arg {
                        statement.push(Statement::Const(StatementConst {
                            value: arg.clone(),
                            output: var_id,
                        }));
                        continue;
                    }
                    parameters.push(var_id);
                }

                let location = LocationId::from_stable_location(
                    db,
                    specialized.base.base_semantic_function(db).stable_location(db),
                );
                let inputs = variables
                    .variables
                    .iter()
                    .map(|(var_id, _)| VarUsage { var_id, location })
                    .collect();

                let outputs: Vec<VariableId> = chain!(
                    base.signature.extra_rets.iter().map(|ret| ret.ty()),
                    [base.signature.return_type]
                )
                .map(|ty| variables.new_var(VarRequest { ty, location }))
                .collect_vec();

                let mut block_builder = BlocksBuilder::new();

                let ret_usage = outputs
                    .iter()
                    .map(|var_id| VarUsage { var_id: *var_id, location })
                    .collect_vec();

                statement.push(Statement::Call(StatementCall {
                    function: specialized.base.function_id(db)?,
                    with_coupon: false,
                    inputs,
                    outputs,
                    location,
                }));
                block_builder.alloc(Block {
                    statements: statement,
                    end: BlockEnd::Return(ret_usage, location),
                });
                Lowered {
                    signature: function.signature(db)?,
                    variables: variables.variables,
                    blocks: block_builder.build().unwrap(),
                    parameters,
                    diagnostics: Default::default(),
                }